package com.xpoint.backend.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.xpoint.backend.common.R;
import com.xpoint.backend.dto.SetmealDto;
import com.xpoint.backend.entity.Category;
import com.xpoint.backend.entity.Setmeal;
import com.xpoint.backend.entity.SetmealDish;
import com.xpoint.backend.mapper.SetmealMapper;
import com.xpoint.backend.service.CategoryService;
import com.xpoint.backend.service.SetmealDishService;
import com.xpoint.backend.service.SetmealService;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.stereotype.Service;
import org.springframework.util.function.SupplierUtils;

import java.util.ArrayList;
import java.util.List;

@Service
//套餐
public class SetmealServiceImpl extends ServiceImpl<SetmealMapper, Setmeal> implements SetmealService {
    @Autowired
    private CategoryService categoryService;

    @Autowired
    private SetmealDishService setmealDishService;

    @Override
    public R<Page> findPage(Long page, Long pageSize, String name) {
//        一.分页查询
//        创建分页
//        List list = new ArrayList<>();
//        list.add();
        Page<Setmeal> page1 = new Page<>(page,pageSize);
//        创建条件构造器
        LambdaQueryWrapper<Setmeal> lambdaQueryWrapper = new LambdaQueryWrapper<>();
//        编写条件：1.name存在，2.setmeal表中的name==传过来的name
        lambdaQueryWrapper.like(name!=null,Setmeal::getName,name);
//        分页查询
        Page<Setmeal> page2 = this.page(page1, lambdaQueryWrapper);

//      二、套餐分类查询
//        创建一个套餐传输对象的
        Page<SetmealDto> setmealDtoPage = new Page<>();
//        将page2的分页数据拷贝给setmealDtoPage，过滤掉records
        BeanUtils.copyProperties(page2,setmealDtoPage,"records");
//        创建一个list接收page中的实体类数据
        List<Setmeal> records = page2.getRecords();
//        创建一个分类List
        List<SetmealDto> categories = new ArrayList<>();
//        遍历实体类，将page2.getRecords中的数据遍历出来，然后存放给setmealDtoPage（套餐传输对象）
        for (Setmeal record : records) {
//            创建一个套餐传输对象
            SetmealDto setmealDto = new SetmealDto();
//            将遍历的实体类record，复制给setmealDto的setmealDishes
            BeanUtils.copyProperties(record,setmealDto);
//            获取实体类中的套餐分类id
            Long categoryId = record.getCategoryId();
//            查询套餐分类id的caregory表
            Category byId = categoryService.getById(categoryId);
//            将查询到的caregory（分类表）表中的name赋值给，套餐传输对象
            if (byId.getName()!=null&&byId.getName()!=""){
                setmealDto.setCategoryName(byId.getName());
            }
            categories.add(setmealDto);
        }
//        将List结果集categories，存到SetmealDto分页中的records
        Page<SetmealDto> setmealDtoPage1 = setmealDtoPage.setRecords(categories);
        if (setmealDtoPage1!=null){
            return R.success(setmealDtoPage1);
        }
        return R.error("失败");
    }

    @Override
//    批量删除操作
    public R<String> updateBatchStatus(int status, List<Long> id) {
//        创建一个list，装Setmeal对象的，后面批量更新会用到
        List<Setmeal> list = new ArrayList();
//        将id遍历出来，然后赋值给setmeal对象中的属性
        for (Long aLong : id) {
            Setmeal setmeal = new Setmeal();
            setmeal.setId(aLong);
            setmeal.setStatus(status);
            list.add(setmeal);
        }
        if (list!=null){
//            然后进行批量更新
            boolean b = this.updateBatchById(list);
            if (b){
                return R.success("成功");
            }
        }
        return R.error("失败");
    }

    @Override
//    批量删除套餐
    public R<String> delelteSetmealBatchById(List<Long> id) {
        if (id!=null) {
            setmealDishService.removeByIds(id);
            if (this.removeByIds(id)) {
                return R.success("删除成功");
            }
        }
        return R.error("删除失败");
    }

    @Override
//        添加套餐
    public R<String> addSetmeal(SetmealDto setmealDto) {
//        创建一个setmeal对象，存放套餐。
        Setmeal setmeal = new Setmeal();
//       将接收的setmealDto（套餐数据传输对象）,复制给setmeal
        BeanUtils.copyProperties(setmealDto,setmeal);
//        添加到setmeal中
        boolean save = this.save(setmeal);
//        获取套餐的菜品
        List<SetmealDish> setmealDishes = setmealDto.getSetmealDishes();
        for (SetmealDish setmealDish : setmealDishes) {
//            在菜品类中添加套餐的id，将他们绑定到同一个套餐
            setmealDish.setSetmealId(setmeal.getId());
        }
//        添加到套餐菜品中
        setmealDishService.saveBatch(setmealDishes);
        if (save){
            return R.success("成功");
        }
        return R.error("失败");
    }

    @Override
    public R<SetmealDto> findSetmeaById(Long id) {
//        一、查询套餐
//        先创建好要返回的对象
        SetmealDto setmealDto = new SetmealDto();
//        根据id查询setmeal表。
        Setmeal setmeal = this.getById(id);
//        将setmeal属性复制给setmealDto
        BeanUtils.copyProperties(setmeal,setmealDto);

//        二、查询套餐的分类
        Long categoryId = setmeal.getCategoryId();
        Category byId = categoryService.getById(categoryId);
        setmealDto.setCategoryName(byId.getName());

//        三、查询套餐的菜品
        Long id1 = setmeal.getId();
        LambdaQueryWrapper<SetmealDish> lambdaQueryWrapper = new LambdaQueryWrapper<>();
        lambdaQueryWrapper.eq(SetmealDish::getSetmealId,id1);
        List<SetmealDish> list = setmealDishService.list(lambdaQueryWrapper);
        if (list!=null){
            setmealDto.setSetmealDishes(list);
            return R.success(setmealDto);
        }

        return R.error("不存在");
    }

    @Override
//    更新套餐信息
    public R<String> UpdateSetmeal(SetmealDto setmealDto) {
//        一、更新套餐
        Setmeal setmeal = new Setmeal();
        BeanUtils.copyProperties(setmealDto,setmeal);
        boolean isSuccess = this.updateById(setmeal);

//        二、更新套餐的菜品信息
//        1.先删除再添加
//        先获取套餐的id，然后在套餐菜品表中，根据套餐的id进行删除
        Long id = setmeal.getId();
//        创建条件构造器
        LambdaQueryWrapper<SetmealDish> lambdaQueryWrapper = new LambdaQueryWrapper<>();
//        id不为空时，条件：套餐的菜品信息数据库setmealId=传过来的id
        lambdaQueryWrapper.eq(id!=null,SetmealDish::getSetmealId,id);
//        执行删除
        setmealDishService.remove(lambdaQueryWrapper);
//        2.添加菜品信息
//        获取前端传过来的对象
        List<SetmealDish> setmealDishes = setmealDto.getSetmealDishes();
//        遍历出来然后给这个集合中的对象分别添加各自的id
        for (SetmealDish setmealDish : setmealDishes) {
            setmealDish.setSetmealId(id);
        }
        setmealDishService.saveBatch(setmealDishes);
        if (isSuccess){
            return R.success("成功");
        }
        return R.error("失败");
    }

    @Override
//    根据分类查询套餐及套餐的菜品
    public R<List<SetmealDto>> findList(String id, Integer status) {
        if (id!=null&&status!=null) {
//            查询套餐
            LambdaQueryWrapper<Setmeal> lambdaQueryWrapper =new LambdaQueryWrapper<>();
            lambdaQueryWrapper.eq(Setmeal::getCategoryId,id);
            List<Setmeal> list = list(lambdaQueryWrapper);
            List<SetmealDto> list1 = new ArrayList<>();
//            根据套餐的id，查询套餐中的菜品
            for (Setmeal setmeal : list) {
                SetmealDto setmealDto = new SetmealDto();
                BeanUtils.copyProperties(setmeal,setmealDto);
                list1.add(setmealDto);
            }
            return R.success(list1);

        }
            return R.error("错误");
    }
}
